<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>JVM内存模型深度解析 | 技术小馆</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.8;
        }
        .hero-bg {
            background: linear-gradient(135deg, #6e8efb 0%, #4a6cf7 100%);
        }
        .section-title {
            position: relative;
            padding-bottom: 1rem;
            margin-bottom: 2rem;
        }
        .section-title:after {
            content: '';
            position: absolute;
            bottom: 0;
            left: 0;
            width: 60px;
            height: 4px;
            background: linear-gradient(to right, #4a6cf7, #6e8efb);
            border-radius: 2px;
        }
        .code-block {
            background-color: #2d2d2d;
            color: #f8f8f2;
            border-radius: 8px;
            overflow: hidden;
        }
        .code-header {
            background-color: #1e1e1e;
            padding: 0.5rem 1rem;
            display: flex;
            align-items: center;
            border-bottom: 1px solid #444;
        }
        .code-dots {
            display: flex;
            gap: 6px;
        }
        .code-dot {
            width: 12px;
            height: 12px;
            border-radius: 50%;
        }
        .dot-red {
            background-color: #ff5f56;
        }
        .dot-yellow {
            background-color: #ffbd2e;
        }
        .dot-green {
            background-color: #27c93f;
        }
        .code-body {
            padding: 1.5rem;
            overflow-x: auto;
        }
        .card {
            transition: all 0.3s ease;
            border-radius: 12px;
            overflow: hidden;
            box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
        }
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .highlight-box {
            border-left: 4px solid #4a6cf7;
            background-color: rgba(74, 108, 247, 0.05);
            padding: 1.5rem;
            border-radius: 0 8px 8px 0;
        }
        .vis-card {
            background: linear-gradient(135deg, #f5f7fa 0%, #e4e8ee 100%);
        }
        .footer-bg {
            background: linear-gradient(135deg, #1a1a1a 0%, #0d0d0d 100%);
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero-bg text-white py-20 md:py-32 px-4">
        <div class="container mx-auto max-w-6xl">
            <div class="flex flex-col md:flex-row items-center">
                <div class="md:w-1/2 mb-10 md:mb-0">
                    <h1 class="text-4xl md:text-5xl font-bold mb-6 leading-tight font-serif">JVM内存模型深度解析</h1>
                    <p class="text-xl md:text-2xl mb-8 opacity-90">探索Java虚拟机的核心架构与性能奥秘</p>
                    <div class="flex flex-wrap gap-4">
                        <div class="px-4 py-2 bg-white bg-opacity-20 rounded-full backdrop-blur-sm flex items-center">
                            <i class="fas fa-microchip mr-2"></i>
                            <span>内存管理</span>
                        </div>
                        <div class="px-4 py-2 bg-white bg-opacity-20 rounded-full backdrop-blur-sm flex items-center">
                            <i class="fas fa-bolt mr-2"></i>
                            <span>高性能</span>
                        </div>
                        <div class="px-4 py-2 bg-white bg-opacity-20 rounded-full backdrop-blur-sm flex items-center">
                            <i class="fas fa-random mr-2"></i>
                            <span>并发控制</span>
                        </div>
                    </div>
                </div>
                <div class="md:w-1/2 flex justify-center">
                    <div class="w-full max-w-md">
                        <div class="mermaid">
                            graph TD
                                A[JVM内存模型] --> B[内存结构]
                                A --> C[内存分配]
                                A --> D[内存回收]
                                A --> E[多线程模型]
                                B --> B1[程序计数器]
                                B --> B2[虚拟机栈]
                                B --> B3[本地方法栈]
                                B --> B4[堆]
                                B --> B5[方法区]
                                B --> B6[运行时常量池]
                                B --> B7[直接内存]
                                C --> C1[栈分配]
                                C --> C2[堆分配]
                                C --> C3[方法区分配]
                                C --> C4[直接内存分配]
                                D --> D1[标记-清除]
                                D --> D2[标记-整理]
                                D --> D3[复制]
                                D --> D4[分代收集]
                                E --> E1[volatile]
                                E --> E2[synchronized]
                                E --> E3[Happens-Before]
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Introduction Section -->
    <section class="py-16 px-4">
        <div class="container mx-auto max-w-6xl">
            <div class="flex flex-col md:flex-row gap-10">
                <div class="md:w-2/3">
                    <h2 class="text-3xl font-bold mb-6 section-title">JVM内存模型</h2>
                    <p class="text-lg mb-6">JVM 是运行 Java 程序的核心环境，而它的内存模型则是决定程序性能、稳定性和安全性的关键因素。它负责管理 Java 程序运行时的内存分配和释放，确保每一个对象和变量都能在合适的时间和位置上被正确使用。</p>
                    
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1717576865006-c9bfcd30-67cd-42f8-983d-9a5879d29e81.png" alt="JVM内存模型示意图" class="w-full rounded-lg shadow-lg mb-8">
                    
                    <p class="text-lg">内存模型的设计直接影响着程序的执行效率，尤其是在处理大规模数据和高并发请求时，合理的内存管理能够显著提升系统的响应速度和资源利用率。</p>
                </div>
                <div class="md:w-1/3">
                    <div class="bg-white p-6 rounded-xl shadow-md sticky top-8">
                        <h3 class="text-xl font-bold mb-4 flex items-center">
                            <i class="fas fa-bookmark text-blue-500 mr-2"></i>
                            内容导航
                        </h3>
                        <ul class="space-y-3">
                            <li><a href="#definition" class="flex items-center text-blue-600 hover:text-blue-800 transition-colors"><i class="fas fa-chevron-right text-xs mr-2"></i>JVM内存模型定义</a></li>
                            <li><a href="#structure" class="flex items-center text-blue-600 hover:text-blue-800 transition-colors"><i class="fas fa-chevron-right text-xs mr-2"></i>JVM内存结构</a></li>
                            <li><a href="#allocation" class="flex items-center text-blue-600 hover:text-blue-800 transition-colors"><i class="fas fa-chevron-right text-xs mr-2"></i>内存分配</a></li>
                            <li><a href="#recycling" class="flex items-center text-blue-600 hover:text-blue-800 transition-colors"><i class="fas fa-chevron-right text-xs mr-2"></i>内存回收</a></li>
                            <li><a href="#multithreading" class="flex items-center text-blue-600 hover:text-blue-800 transition-colors"><i class="fas fa-chevron-right text-xs mr-2"></i>内存模型与多线程</a></li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Definition Section -->
    <section id="definition" class="py-16 px-4 bg-gray-50">
        <div class="container mx-auto max-w-6xl">
            <h2 class="text-3xl font-bold mb-6 section-title">JVM 内存模型的定义</h2>
            <p class="text-lg mb-8">Java 虚拟机（JVM）内存模型是一种抽象的计算模型，用于定义 JVM 在运行 Java 应用程序时如何管理和组织内存。它详细描述了内存的各个部分，包括如何分配、访问、和回收内存，以确保 Java 程序的正确执行。</p>
            
            <div class="grid md:grid-cols-2 gap-8 mb-12">
                <div class="card bg-white">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1717577068380-89316ee1-27c0-42be-8a96-85538f8a0ac7.png" alt="JVM内存模型定义" class="w-full rounded-t-lg">
                    <div class="p-6">
                        <h3 class="text-xl font-bold mb-3">核心目标</h3>
                        <ul class="space-y-3">
                            <li class="flex items-start">
                                <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                                <span>高效内存管理：减少内存碎片和资源浪费</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                                <span>自动垃圾回收：避免内存泄漏和程序崩溃</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                                <span>线程并发控制：确保多线程环境下的操作安全</span>
                            </li>
                        </ul>
                    </div>
                </div>
                <div>
                    <div class="highlight-box mb-8">
                        <h3 class="text-xl font-bold mb-3 flex items-center">
                            <i class="fas fa-lightbulb text-blue-500 mr-2"></i>
                            关键特性
                        </h3>
                        <p>JVM 内存模型通过定义内存可见性和操作的原子性，确保在多线程环境中，各线程对共享内存的操作是安全和一致的。通过使用 volatile 关键字和 synchronized 块，开发者可以控制变量的可见性和同步，从而避免竞争条件和数据不一致。</p>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow-sm">
                        <h3 class="text-xl font-bold mb-3 flex items-center">
                            <i class="fas fa-shield-alt text-blue-500 mr-2"></i>
                            线程安全
                        </h3>
                        <p>在多线程环境中，内存模型需要确保各线程对共享内存的操作是安全的，避免竞争条件和数据不一致问题。通过定义内存可见性和同步机制，内存模型为线程安全提供了保障。</p>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Structure Section -->
    <section id="structure" class="py-16 px-4">
        <div class="container mx-auto max-w-6xl">
            <h2 class="text-3xl font-bold mb-6 section-title">JVM 内存结构</h2>
            <p class="text-lg mb-8">JVM 内存结构是指 JVM 在运行 Java 应用程序时如何组织和管理内存的具体方式。这一结构划分了多个不同的内存区域，每个区域都有特定的用途和管理机制。</p>
            
            <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1654432779028-b0d6224f-0955-4ad0-8768-7abd7b0e11ce.png?x-oss-process=image%2Fresize%2Cw_812%2Climit_0%2Fresize%2Cw_812%2Climit_0" alt="JVM内存结构" class="w-full rounded-lg shadow-lg mb-12">
            
            <div class="grid md:grid-cols-2 lg:grid-cols-3 gap-6">
                <div class="card bg-white">
                    <div class="p-6">
                        <div class="flex items-center mb-4">
                            <div class="w-12 h-12 rounded-full bg-blue-100 flex items-center justify-center mr-4">
                                <i class="fas fa-microchip text-blue-500 text-xl"></i>
                            </div>
                            <h3 class="text-xl font-bold">程序计数器</h3>
                        </div>
                        <p class="text-gray-700">JVM 内存模型中最小的一块内存区域，每个线程都有一个独立的程序计数器。它用于存储当前线程所执行的字节码指令的地址，指示下一条指令的位置。</p>
                    </div>
                </div>
                
                <div class="card bg-white">
                    <div class="p-6">
                        <div class="flex items-center mb-4">
                            <div class="w-12 h-12 rounded-full bg-purple-100 flex items-center justify-center mr-4">
                                <i class="fas fa-layer-group text-purple-500 text-xl"></i>
                            </div>
                            <h3 class="text-xl font-bold">Java 虚拟机栈</h3>
                        </div>
                        <p class="text-gray-700">线程私有的，每个线程在创建时会分配一个虚拟机栈，用于存储栈帧（Frame）。每个栈帧对应一次方法调用，包含局部变量表、操作数栈、动态链接、方法出口等信息。</p>
                    </div>
                </div>
                
                <div class="card bg-white">
                    <div class="p-6">
                        <div class="flex items-center mb-4">
                            <div class="w-12 h-12 rounded-full bg-green-100 flex items-center justify-center mr-4">
                                <i class="fas fa-code text-green-500 text-xl"></i>
                            </div>
                            <h3 class="text-xl font-bold">本地方法栈</h3>
                        </div>
                        <p class="text-gray-700">与 Java 虚拟机栈类似，但它是为虚拟机使用的 Native 方法服务的。它的功能和 Java 虚拟机栈类似，会在调用和返回 Native 方法时创建和销毁栈帧。</p>
                    </div>
                </div>
                
                <div class="card bg-white">
                    <div class="p-6">
                        <div class="flex items-center mb-4">
                            <div class="w-12 h-12 rounded-full bg-red-100 flex items-center justify-center mr-4">
                                <i class="fas fa-database text-red-500 text-xl"></i>
                            </div>
                            <h3 class="text-xl font-bold">堆</h3>
                        </div>
                        <p class="text-gray-700">所有线程共享的一块内存区域，用于存储所有的对象实例和数组。堆是垃圾回收的主要管理区域，几乎所有的对象都在这里分配。</p>
                    </div>
                </div>
                
                <div class="card bg-white">
                    <div class="p-6">
                        <div class="flex items-center mb-4">
                            <div class="w-12 h-12 rounded-full bg-yellow-100 flex items-center justify-center mr-4">
                                <i class="fas fa-cube text-yellow-500 text-xl"></i>
                            </div>
                            <h3 class="text-xl font-bold">方法区</h3>
                        </div>
                        <p class="text-gray-700">所有线程共享的内存区域，用于存储已被 JVM 加载的类信息、常量、静态变量、即时编译器（JIT Compiler）编译后的代码等数据。</p>
                    </div>
                </div>
                
                <div class="card bg-white">
                    <div class="p-6">
                        <div class="flex items-center mb-4">
                            <div class="w-12 h-12 rounded-full bg-indigo-100 flex items-center justify-center mr-4">
                                <i class="fas fa-link text-indigo-500 text-xl"></i>
                            </div>
                            <h3 class="text-xl font-bold">运行时常量池</h3>
                        </div>
                        <p class="text-gray-700">方法区的一部分，用于存放编译期生成的各种字面量和符号引用。这些常量在类加载后进入运行时常量池，并在运行期间动态解析。</p>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Allocation Section -->
    <section id="allocation" class="py-16 px-4 bg-gray-50">
        <div class="container mx-auto max-w-6xl">
            <h2 class="text-3xl font-bold mb-6 section-title">内存分配</h2>
            <p class="text-lg mb-8">内存分配与回收是由 JVM 管理的核心任务之一。内存分配决定了对象和变量的存储位置，而内存回收则负责清除不再使用的对象，释放内存资源。</p>
            
            <div class="grid md:grid-cols-2 gap-8 mb-12">
                <div>
                    <h3 class="text-2xl font-bold mb-4 flex items-center">
                        <i class="fas fa-layer-group text-blue-500 mr-2"></i>
                        栈上的内存分配
                    </h3>
                    <p class="mb-4">栈内存用于存储局部变量和方法调用的栈帧。每个线程都有自己的栈内存，随着方法的调用和返回，栈帧会按照先进后出（LIFO）原则压入和弹出。栈上的内存分配速度快，因为只需简单地调整栈指针。但由于栈内存大小有限，可能会出现 StackOverflowError。</p>
                    <ul class="space-y-3 mb-6">
                        <li class="flex items-start">
                            <i class="fas fa-circle text-xs text-blue-500 mt-2 mr-2"></i>
                            <span><strong>局部变量：</strong>方法内部声明的基本类型变量和对象引用（不包括对象本身）都存储在栈上。</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-circle text-xs text-blue-500 mt-2 mr-2"></i>
                            <span><strong>栈帧：</strong>每次方法调用时，都会创建一个新的栈帧，用于存储该方法的局部变量表、操作数栈、动态链接和方法出口。</span>
                        </li>
                    </ul>
                </div>
                
                <div>
                    <h3 class="text-2xl font-bold mb-4 flex items-center">
                        <i class="fas fa-database text-blue-500 mr-2"></i>
                        堆上的内存分配
                    </h3>
                    <p class="mb-4">堆内存是所有线程共享的区域，用于存储所有的对象实例和数组。堆内存的分配较为复杂，但灵活性高，适合存储生命周期较长的数据。</p>
                    <ul class="space-y-3 mb-6">
                        <li class="flex items-start">
                            <i class="fas fa-circle text-xs text-blue-500 mt-2 mr-2"></i>
                            <span><strong>新生代和老年代：</strong>堆被分为新生代（Young Generation）和老年代（Old Generation）。新生代又细分为 Eden 区和两个 Survivor 区。大部分新创建的对象首先分配在 Eden 区。</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-circle text-xs text-blue-500 mt-2 mr-2"></i>
                            <span><strong>分配策略：</strong>对象优先分配在新生代的 Eden 区，Eden 区满时，进行 Minor GC，将仍存活的对象移动到 Survivor 区或老年代。</span>
                        </li>
                    </ul>
                </div>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <h3 class="text-2xl font-bold mb-4 flex items-center">
                        <i class="fas fa-code text-blue-500 mr-2"></i>
                        方法区和运行时常量池
                    </h3>
                    <p class="mb-4">方法区（也称为永久代或元空间）存储已加载的类信息、常量、静态变量、即时编译后的代码等数据。运行时常量池是方法区的一部分，存储编译期生成的各种字面量和符号引用。</p>
                    <ul class="space-y-3">
                        <li class="flex items-start">
                            <i class="fas fa-circle text-xs text-blue-500 mt-2 mr-2"></i>
                            <span><strong>方法区分配：</strong>类加载器在加载类时，将类的元数据、常量池信息等存储在方法区。静态变量和常量池中的符号引用也在方法区分配。</span>
                        </li>
                    </ul>
                </div>
                
                <div>
                    <h3 class="text-2xl font-bold mb-4 flex items-center">
                        <i class="fas fa-memory text-blue-500 mr-2"></i>
                        直接内存
                    </h3>
                    <p class="mb-4">直接内存不在 JVM 堆内存中，而是在本地内存中分配。主要用于高性能 I/O 操作，减少内存复制，提高吞吐量。通过 <code class="bg-gray-200 px-1 rounded">java.nio</code> 包中的 <code class="bg-gray-200 px-1 rounded">ByteBuffer</code> 类分配和管理。</p>
                    <ul class="space-y-3">
                        <li class="flex items-start">
                            <i class="fas fa-circle text-xs text-blue-500 mt-2 mr-2"></i>
                            <span><strong>分配方式：</strong>直接内存通过操作系统的本地方法库分配，不受 JVM 堆大小的限制，但会受到本机内存的限制。</span>
                        </li>
                    </ul>
                </div>
            </div>
        </div>
    </section>

    <!-- Recycling Section -->
    <section id="recycling" class="py-16 px-4">
        <div class="container mx-auto max-w-6xl">
            <h2 class="text-3xl font-bold mb-6 section-title">内存回收</h2>
            <p class="text-lg mb-8">垃圾回收（Garbage Collection，GC）是 JVM 内存管理的重要组成部分，用于自动回收不再使用的对象，释放内存空间。GC 通过多种算法实现高效回收，包括标记-清除、标记-整理、复制和分代收集等。</p>
            
            <div class="grid md:grid-cols-2 gap-8 mb-12">
                <div>
                    <h3 class="text-2xl font-bold mb-4 flex items-center">
                        <i class="fas fa-recycle text-blue-500 mr-2"></i>
                        垃圾回收机制
                    </h3>
                    <ul class="space-y-4">
                        <li>
                            <h4 class="font-bold text-lg mb-2">标记-清除（Mark-Sweep）</h4>
                            <p class="text-gray-700">首先标记所有存活的对象，然后清除未标记的对象。标记-清除算法效率较低，容易产生内存碎片。</p>
                        </li>
                        <li>
                            <h4 class="font-bold text-lg mb-2">标记-整理（Mark-Compact）</h4>
                            <p class="text-gray-700">在标记阶段后，将存活对象向一端移动，然后清除无效区域。标记-整理减少了内存碎片，但整理阶段需要较长时间。</p>
                        </li>
                        <li>
                            <h4 class="font-bold text-lg mb-2">复制（Copying）</h4>
                            <p class="text-gray-700">将存活对象从一个区域复制到另一个区域，然后清空原区域。复制算法效率较高，适合新生代垃圾回收，但空间利用率较低。</p>
                        </li>
                        <li>
                            <h4 class="font-bold text-lg mb-2">分代收集（Generational GC）</h4>
                            <p class="text-gray-700">将堆内存分为新生代和老年代，不同代使用不同的回收算法。新生代对象存活时间短，使用复制算法；老年代对象存活时间长，使用标记-整理或标记-清除算法。</p>
                        </li>
                    </ul>
                </div>
                
                <div>
                    <h3 class="text-2xl font-bold mb-4 flex items-center">
                        <i class="fas fa-server text-blue-500 mr-2"></i>
                        垃圾回收器
                    </h3>
                    <div class="card vis-card p-6 mb-6">
                        <div class="mermaid">
                            pie
                                title 垃圾回收器应用场景
                                "Serial GC" : 15
                                "Parallel GC" : 30
                                "CMS GC" : 25
                                "G1 GC" : 30
                        </div>
                    </div>
                    <ul class="space-y-4">
                        <li>
                            <h4 class="font-bold text-lg mb-2">Serial GC</h4>
                            <p class="text-gray-700">单线程垃圾回收器，适用于单核处理器和小内存应用。其停顿时间较长，不适合多线程和大内存环境。</p>
                        </li>
                        <li>
                            <h4 class="font-bold text-lg mb-2">Parallel GC</h4>
                            <p class="text-gray-700">多线程垃圾回收器，通过多线程并行执行垃圾回收，适用于多核处理器和高吞吐量应用。</p>
                        </li>
                        <li>
                            <h4 class="font-bold text-lg mb-2">CMS GC</h4>
                            <p class="text-gray-700">并发标记-清除垃圾回收器，减少停顿时间，适用于低停顿需求的应用，但在老年代内存碎片多时会降低性能。</p>
                        </li>
                        <li>
                            <h4 class="font-bold text-lg mb-2">G1 GC</h4>
                            <p class="text-gray-700">面向服务器端应用的垃圾回收器，设计目标是低停顿和高吞吐量，通过区域化分配和回收，减少内存碎片。</p>
                        </li>
                    </ul>
                </div>
            </div>
            
            <div class="bg-white p-8 rounded-xl shadow-md">
                <h3 class="text-2xl font-bold mb-4 flex items-center">
                    <i class="fas fa-exclamation-triangle text-red-500 mr-2"></i>
                    内存泄漏与 OutOfMemoryError
                </h3>
                <p class="mb-6">内存泄漏是指对象不再使用但未被垃圾回收器回收，导致内存持续占用。内存泄漏会引发 OutOfMemoryError，导致应用程序崩溃。常见原因包括静态集合类（如 <code class="bg-gray-200 px-1 rounded">HashMap</code>）持有对象引用、线程未正确终止等。</p>
                
                <div class="highlight-box">
                    <h4 class="font-bold text-lg mb-2 flex items-center">
                        <i class="fas fa-search text-blue-500 mr-2"></i>
                        诊断与优化建议
                    </h4>
                    <p>使用工具（如 VisualVM、MAT）分析堆转储，找出内存泄漏的根源。通过合理设计代码、及时清理无用对象引用，减少内存泄漏的发生。</p>
                </div>
            </div>
        </div>
    </section>

    <!-- Multithreading Section -->
    <section id="multithreading" class="py-16 px-4 bg-gray-50">
        <div class="container mx-auto max-w-6xl">
            <h2 class="text-3xl font-bold mb-6 section-title">内存模型与多线程</h2>
            <p class="text-lg mb-8">内存模型（Java Memory Model, JMM）定义了多线程环境下的内存访问规则，确保线程间通信的正确性和一致性。</p>
            
            <div class="grid md:grid-cols-2 gap-8 mb-12">
                <div>
                    <h3 class="text-2xl font-bold mb-4">基本概念</h3>
                    <p class="mb-4">Java 内存模型定义了变量（包括实例字段、静态字段和数组元素）在多个线程间的可见性和有序性。它主要解决两个问题：<strong>缓存一致性</strong>和<strong>指令重排序</strong>。</p>
                    
                    <ul class="space-y-3 mb-6">
                        <li class="flex items-start">
                            <i class="fas fa-circle text-xs text-blue-500 mt-2 mr-2"></i>
                            <span><strong>缓存一致性：</strong>在多线程环境中，每个线程可能会在自己的工作内存中缓存变量的值。JMM 保证不同线程之间对共享变量的更新能够在合理的时间内彼此可见。</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-circle text-xs text-blue-500 mt-2 mr-2"></i>
                            <span><strong>指令重排序：</strong>为了优化性能，编译器和处理器可能会对指令进行重排序。JMM 规定了重排序的规则，确保多线程程序的正确性。</span>
                        </li>
                    </ul>
                    
                    <h3 class="text-2xl font-bold mb-4">volatile 关键字</h3>
                    <p class="mb-4"><code class="bg-gray-200 px-1 rounded">volatile</code> 关键字是 Java 提供的一种轻量级同步机制，确保变量的可见性和有序性。</p>
                    
                    <div class="code-block mb-4">
                        <div class="code-header">
                            <div class="code-dots">
                                <div class="code-dot dot-red"></div>
                                <div class="code-dot dot-yellow"></div>
                                <div class="code-dot dot-green"></div>
                            </div>
                            <span class="text-gray-400 ml-2 text-sm">VolatileDemo.java</span>
                        </div>
                        <div class="code-body">
                            <pre><code class="text-sm">class VolatileDemo {
    private volatile boolean flag = false;

    public void writer() {
        flag = true; // 写操作
    }

    public void reader() {
        if (flag) { // 读操作
            // 执行一些逻辑
        }
    }
}</code></pre>
                        </div>
                    </div>
                    
                    <ul class="space-y-3">
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                            <span><strong>可见性：</strong>当一个线程修改了 <code class="bg-gray-200 px-1 rounded">volatile</code> 变量的值，新的值立即被刷新到主内存中。</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                            <span><strong>禁止重排序：</strong><code class="bg-gray-200 px-1 rounded">volatile</code> 变量的读写操作不会与其他内存操作重排序。</span>
                        </li>
                    </ul>
                </div>
                
                <div>
                    <h3 class="text-2xl font-bold mb-4">synchronized 关键字</h3>
                    <p class="mb-4"><code class="bg-gray-200 px-1 rounded">synchronized</code> 关键字提供了更强的同步机制，除了保证可见性和有序性外，还确保了操作的原子性。</p>
                    
                    <div class="code-block mb-4">
                        <div class="code-header">
                            <div class="code-dots">
                                <div class="code-dot dot-red"></div>
                                <div class="code-dot dot-yellow"></div>
                                <div class="code-dot dot-green"></div>
                            </div>
                            <span class="text-gray-400 ml-2 text-sm">SynchronizedDemo.java</span>
                        </div>
                        <div class="code-body">
                            <pre><code class="text-sm">class SynchronizedDemo {
    private int count = 0;

    public synchronized void increment() {
        count++; // 原子操作
    }

    public synchronized int getCount() {
        return count; // 可见性和有序性保证
    }
}</code></pre>
                        </div>
                    </div>
                    
                    <h3 class="text-2xl font-bold mb-4 mt-8">Happens-Before 原则</h3>
                    <p class="mb-4">JMM 提供了 happens-before 原则，用于判断操作之间的可见性和有序性关系。happens-before 关系是构建线程安全程序的基础。</p>
                    
                    <ul class="space-y-3">
                        <li class="flex items-start">
                            <i class="fas fa-arrow-right text-blue-500 mt-1 mr-2"></i>
                            <span><strong>程序次序规则：</strong>在一个线程内，按照程序的顺序，前面的操作 happens-before 后面的操作。</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-arrow-right text-blue-500 mt-1 mr-2"></i>
                            <span><strong>锁规则：</strong>一个锁的解锁 happens-before 后续对这个锁的加锁。</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-arrow-right text-blue-500 mt-1 mr-2"></i>
                            <span><strong>volatile 变量规则：</strong>对一个 <code class="bg-gray-200 px-1 rounded">volatile</code> 变量的写操作 happens-before 后续对这个 <code class="bg-gray-200 px-1 rounded">volatile</code> 变量的读操作。</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-arrow-right text-blue-500 mt-1 mr-2"></i>
                            <span><strong>线程启动规则：</strong><code class="bg-gray-200 px-1 rounded">Thread.start()</code> 方法调用 happens-before 该线程内的所有操作。</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-arrow-right text-blue-500 mt-1 mr-2"></i>
                            <span><strong>线程终止规则：</strong>线程内的所有操作 happens-before 另一个线程调用 <code class="bg-gray-200 px-1 rounded">Thread.join()</code> 并成功返回。</span>
                        </li>
                    </ul>
                </div>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <h3 class="text-2xl font-bold mb-4">线程安全的单例模式</h3>
                    <p class="mb-4">通过双重检查锁定（DCL）和 <code class="bg-gray-200 px-1 rounded">volatile</code> 关键字实现线程安全的单例模式。</p>
                    
                    <div class="code-block">
                        <div class="code-header">
                            <div class="code-dots">
                                <div class="code-dot dot-red"></div>
                                <div class="code-dot dot-yellow"></div>
                                <div class="code-dot dot-green"></div>
                            </div>
                            <span class="text-gray-400 ml-2 text-sm">Singleton.java</span>
                        </div>
                        <div class="code-body">
                            <pre><code class="text-sm">class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}</code></pre>
                        </div>
                    </div>
                </div>
                
                <div>
                    <h3 class="text-2xl font-bold mb-4">安全发布对象</h3>
                    <p class="mb-4">确保对象在发布前完全构建，避免未初始化对象被其他线程看到。</p>
                    
                    <div class="code-block">
                        <div class="code-header">
                            <div class="code-dots">
                                <div class="code-dot dot-red"></div>
                                <div class="code-dot dot-yellow"></div>
                                <div class="code-dot dot-green"></div>
                            </div>
                            <span class="text-gray-400 ml-2 text-sm">SafePublish.java</span>
                        </div>
                        <div class="code-body">
                            <pre><code class="text-sm">class SafePublish {
    private Holder holder;

    public synchronized void initialize() {
        holder = new Holder(42); // 安全发布
    }

    public Holder getHolder() {
        return holder;
    }
}

class Holder {
    private int value;

    public Holder(int value) {
        this.value = value;
    }
}</code></pre>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Related Resources -->
    <section class="py-16 px-4">
        <div class="container mx-auto max-w-6xl">
            <h2 class="text-3xl font-bold mb-6 section-title">扩展阅读</h2>
            
            <div class="grid md:grid-cols-2 gap-6">
                <div class="card bg-white">
                    <div class="p-6">
                        <h3 class="text-xl font-bold mb-3 flex items-center">
                            <i class="fas fa-key text-blue-500 mr-2"></i>
                            Volatile关键字详解
                        </h3>
                        <p class="text-gray-700 mb-4">深入探讨 volatile 关键字在多线程环境中的工作原理和使用场景。</p>
                        <a href="#" class="text-blue-500 hover:text-blue-700 font-medium inline-flex items-center">
                            阅读更多 <i class="fas fa-arrow-right ml-1"></i>
                        </a>
                    </div>
                </div>
                
                <div class="card bg-white">
                    <div class="p-6">
                        <h3 class="text-xl font-bold mb-3 flex items-center">
                            <i class="fas fa-lock text-blue-500 mr-2"></i>
                            Java中的锁机制
                        </h3>
                        <p class="text-gray-700 mb-4">全面解析 Java 中各种锁机制，包括 synchronized、ReentrantLock、读写锁等。</p>
                        <a href="https://www.yuque.com/jtostring/qiwsg9/yioy3o?singleDoc# 《Java中锁机制》" class="text-blue-500 hover:text-blue-700 font-medium inline-flex items-center">
                            阅读更多 <i class="fas fa-arrow-right ml-1"></i>
                        </a>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Footer -->
    <footer class="footer-bg text-white py-12 px-4">
        <div class="container mx-auto max-w-6xl">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-6 md:mb-0">
                    <h3 class="text-xl font-bold mb-2">技术小馆</h3>
                    <p class="text-gray-400">探索技术的魅力，分享知识的价值</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-blue-400 hover:text-blue-300 transition-colors inline-flex items-center">
                        <i class="fas fa-external-link-alt mr-2"></i>
                        访问语雀主页
                    </a>
                </div>
            </div>
            <div class="border-t border-gray-800 mt-8 pt-8 text-center text-gray-400 text-sm">
                <p>© 2024 技术小馆. 版权所有</p>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true,
                curve: 'basis'
            },
            securityLevel: 'loose'
        });
    </script>
</body>
</html>